home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / compstol / cmpsttl1.lha / CompositeTool / v1.1.dist / HDF / df.c next >
Encoding:
C/C++ Source or Header  |  1990-05-08  |  44.8 KB  |  1,418 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.00
  4. *                December, 1989
  5. *
  6. * NCSA HDF Version 3.00 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. /*-----------------------------------------------------------------------------
  23.  * File:    df.c
  24.  * Purpose: HDF low level file access
  25.  * Invokes: df.h
  26.  * Contents: 
  27.  *  DFImemcopy: copy bytes, on machines with no memcpy equivalents
  28.  *  DFopen: open HDF file
  29.  *  DFclose: close HDF file
  30.  *  DFIseedDDs: read data descriptors into memory
  31.  *  DFIcheck: check that dfile is a valid HDF file pointer
  32.  *  DFdescriptors: return a list of the data descriptors in the HDF file
  33.  *  DFnumber: count the number of occurrences of a given tag in the HDF file
  34.  *  DFsetfind: set up a search
  35.  *  DFfind: search for tag/ref combination
  36.  *  DFIfind: internal routine to actually perform search
  37.  *  DFIemptyDD: find an empty DD in the HDF file, or create one
  38.  *  DFaccess: set up a read/write on a data element
  39.  *  DFstart: set up a read/write on a data element
  40.  *  DFread: read a portion of a data element
  41.  *  DFseek: seek to new position within data element
  42.  *  DFwrite: write portion of a data element
  43.  *  DFupdate: write out updated DDs to HDF file
  44.  *  DFstat: provide status information about HDF file
  45.  *  DFgetelement: read an entire data element
  46.  *  DFputelement: write an entire data element
  47.  *  DFdup: create an additional descriptor for a data element
  48.  *  DFdel: delete a data element
  49.  *  DFnewref: Get an unused reference number
  50.  *  DFishdf: is this an HDF file?
  51.  *  DFerrno: return value of DFerror
  52.  *  DFIerr: close a file saving DFerror, return -1, for error handling.
  53.  * Remarks: These are the only routines which access HDF files directly
  54.  *---------------------------------------------------------------------------*/
  55.  
  56. #define DFMASTER
  57. #include "df.h"
  58.  
  59. #define CKMALLOC( x, ret) { if (!x) { DFerror = DFE_NOSPACE; return(ret); } }
  60.  
  61. #define CKSEEK(x,y,z, ret)  {  if (DF_SEEK( x,(long)y,z) <0) \
  62.                 {DFerror = DFE_SEEKERROR; return(ret); } }
  63.  
  64. #define CKSEEKEND(x,y,z, ret)   {  if (DF_SKEND( x,(long)y,z) <0) \
  65.                 {DFerror = DFE_SEEKERROR; return(ret); } }
  66.  
  67. #ifdef VMS
  68. #define CKREAD(x,y,z,f, ret)    { \
  69.                 int32 currfileposn; \
  70.                 currfileposn = DF_TELL(f); \
  71.                 if (DF_READ( (char*)x, (int)(y), (int)(z), (f))<0) \
  72.                 { DFerror = DFE_READERROR; return(ret); } \
  73.                 DF_SEEK(f, (long) (currfileposn + y*z), 0); \
  74.                 }
  75. #else /*VMS*/
  76. #define CKREAD(x,y,z,f, ret)    { \
  77.                 if (DF_READ( (char*)x, (int)(y), (int)(z), (f))<0) \
  78.                 { DFerror = DFE_READERROR; return(ret); } \
  79.                 }
  80. #endif /*VMS*/
  81.  
  82. #define CKWRITE(x,y,z,f, ret)   { if (DF_WRITE( (char*)x, (int)y, (int)z,f)<0) \
  83.                 {DFerror = DFE_WRITEERROR; return(ret); } }
  84.  
  85. /*
  86.  *  Important Internal Variables
  87.  */
  88. static DF *DFlist=NULL;        /* pointer to list of open DFs */
  89. static int DFinuse=0;        /* How many are currently in use */
  90. static uint16 DFmaxref;        /* which is the largest ref used? */
  91. static unsigned char *DFreflist=NULL; /* list of refs in use */
  92. static char patterns[] = {0x80, 0x40, 0x20, 0x10, 0x08,
  93.                        0x04, 0x02, 0x01};
  94.  
  95. /*-----------------------------------------------------------------------------
  96.  * Name:    DFImemcopy
  97.  * Purpose: Copy bytes from one place to another
  98.  * Inputs:  from, to: source and destination for copy
  99.  *          length: number of bytes to copy
  100.  * Returns: 0 on success, -1 on failure with DFerror set
  101.  * Users:   HDF systems programmers, on machines without memcpy equivalents
  102.  * Remarks: assumes non-overlapping
  103.  *          Intended for machines on which memcppy etc. do not work
  104.  *---------------------------------------------------------------------------*/
  105.  
  106. DFImemcopy( from, to, length)
  107. char *from, *to;
  108. register int length;
  109. {
  110.     length++;
  111.     while (--length) *to++ = *from++;
  112.     return(0);
  113. }
  114.  
  115. /*-----------------------------------------------------------------------------
  116.  * Name:    DFopen
  117.  * Purpose: open DF file if it exists, else create it if write access
  118.  * Inputs:  name: name of file to open
  119.  *          access: DFACC_READ, DFACC_WRITE, DFACC_CREATE, DFACC_ALL
  120.  *          ndds: number of dds in a block
  121.  * Returns: DF ptr to open file on success, NULL on failure with DFerror set
  122.  * Invokes: DFIseedDDs 
  123.  * Users:   HDF programmers, many HDF user-level routines, utilities
  124.  * Remarks: Contains hooks for multiple DF files open simultaneously
  125.  *---------------------------------------------------------------------------*/
  126.  
  127. DF *DFopen( name, access, ndds )
  128. char *name;
  129. int access;
  130. int ndds;
  131. {
  132.     int created, i;             /* created is true if file is newly created */
  133.  
  134.                     /* error checking */
  135.     DFerror = DFE_NOERROR;
  136.  
  137.     if (!(*name)) {                             /* check name */
  138.         DFerror = DFE_BADNAME;
  139.         return(NULL);
  140.     }
  141.  
  142.     if ((access & (DFACC_ALL))!= access || access==0) {     /* check access */
  143.         DFerror = DFE_BADACC;
  144.         return(NULL); 
  145.     }
  146.     
  147.     if (DFinuse >= DF_MAXDFS) {    /* is DF table filled up? */
  148.         DFerror = DFE_TOOMANY; 
  149.         return(NULL);  
  150.     }
  151.     
  152.                 /* open file, set it up */
  153.         /* set up space for list of DFs */
  154.     if (!DFlist) {
  155.         DFlist = (DF *) malloc(DF_MAXDFS * sizeof(DF));
  156.         for (i=0; i<DF_MAXDFS; i++)
  157.             DFlist[i].type = 0;    /* mark free */
  158.     }
  159.  
  160.         /* locate unused slot in table */
  161.     for (i=0; i<DF_MAXDFS && DFlist[ i].type != 0; i++);
  162.  
  163.     if ( i>=DF_MAXDFS) {                            /* no free slot */
  164.         DFerror = DFE_TOOMANY;
  165.         return(NULL); 
  166.     }
  167.  
  168.     if (access == DFACC_CREATE) {
  169.         created = 1;
  170.         access = DFACC_WRITE;                   /* equivalent to write */
  171.     }
  172.     else created = 0;
  173.  
  174.         /* does an extra open just to check if file exists */
  175.     if (created || !(DFlist[i].file = DF_OPEN(name, DF_RDACCESS))) {
  176.         if (access<2) {         /* file does not exist, check if read access */
  177.             DFerror = DFE_FNF;  /* file not found */
  178.             return(NULL);
  179.         }
  180.         close (DF_CREAT( name, 0666));  /* else create the file */
  181.         created=1;
  182.     }
  183.     else
  184.         DF_CLOSE(DFlist[i].file);   /* open successful, close it */
  185.  
  186.         /* open file with correct access mode */
  187.     if ( !(DFlist[i].file = DF_OPEN( name, 
  188.         ((access>1) ? DF_WRACCESS : DF_RDACCESS ))) ) {
  189.         DFerror = DFE_BADOPEN;
  190.         return(NULL);
  191.     }
  192.  
  193.     if (created) {      /* Create a DDH and DD's for a new file */
  194.         DFdd dd;
  195.         DFddh ddh;
  196.     char magick[4];
  197.         int j;
  198.  
  199.     strncpy(magick, DF_MAGICK, 4); /* magick number */
  200.         CKWRITE( magick,4,1,DFlist[i].file, NULL);
  201.  
  202.         ddh.next=0;                         /* only one DDH */
  203.         if (ndds<=0) DFlist[i].defdds = DF_DEFAULTDDS;  
  204.         else DFlist[i].defdds = ndds;       /* set up number of DDs in block */
  205.         ddh.dds = DFlist[i].defdds;
  206.         dd.tag=DFTAG_NULL;              /* set up empty DD */
  207.         dd.ref=0;                       /* offset, length don't care */
  208.  
  209. #ifdef DF_STRUCTOK                      /* okay to write structures? */
  210.         CKWRITE( &ddh, sizeof(DFddh), 1, DFlist[i].file, NULL); /* write it */
  211. #else /*DF_STRUCTOK*/
  212.         {
  213.             register char *p;
  214.             /* copy structure into buffer, write it out */
  215.             p = DFtbuf;
  216.             INT16WRITE( p, ddh.dds);    /* header */
  217.             INT32WRITE( p, ddh.next);
  218.             CKWRITE( DFtbuf, 6, 1, DFlist[i].file, NULL);   /* 6=header size */
  219.         }
  220. #endif /*DF_STRUCTOK*/
  221.  
  222.         for (j=0; j<ddh.dds; j++) {             /* write out DDs */
  223. #ifdef DF_STRUCTOK
  224.             CKWRITE( &dd, sizeof(DFdd),1, DFlist[i].file, NULL);
  225. #else /*DF_STRUCTOK*/
  226.             {
  227.                 register char *p;
  228.                 p = DFtbuf;
  229.                 UINT16WRITE( p, dd.tag);
  230.                 UINT16WRITE( p, dd.ref);
  231.                 INT32WRITE( p, dd.offset);
  232.                 INT32WRITE( p, dd.length);
  233.                 CKWRITE( DFtbuf, 12, 1, DFlist[i].file, NULL); /* 12=DD size */
  234.             }
  235. #endif /*DF_STRUCTOK*/
  236.         }
  237.     }
  238.     else {            /* if file already exists */
  239.          char magick[4];
  240.  
  241.         CKREAD( magick, 4, 1, DFlist[i].file, NULL); /* check magick number */
  242.         if ( strncmp(magick,DF_MAGICK,4)) {
  243.             DFerror = DFE_NOTDFFILE;
  244.             DF_CLOSE(DFlist[i].file);
  245.             return(NULL);
  246.         }
  247.     }
  248.  
  249.     /* store status information in struct */
  250.     if (ndds<=0) DFlist[i].defdds = DF_DEFAULTDDS;  
  251.     else DFlist[i].defdds = ndds;
  252.     DFlist[i].access=access;
  253.     DFlist[i].list = NULL;
  254.     DFlist[i].changed=0;
  255.     DFlist[i].last_tag= 0;
  256.     DFlist[i].last_ref= 0;
  257.     DFlist[i].type=1;
  258.     DFlist[i].up_access=0;
  259.     DFlist[i].up_dd = NULL;
  260.  
  261.             /* read DDs and store the information in internal structure */
  262.     if (DFIseedDDs( &DFlist[i]) <0) return(NULL);
  263.  
  264.     if (created) {                  /* create MT if new file */
  265.         DFdd *dd;
  266.         dd = &(DFlist[i].list->next->dd[0]);    /* first dd is in 2nd dle */
  267.         dd->tag = DFTAG_MT;
  268.         dd->ref = DF_MT;
  269.         dd->offset = 0;
  270.         dd->length = 0;
  271.     }
  272.     DFinuse++;                      /* no of DF slots in use */
  273.     return( &DFlist[i]);            /* DF file pointer */
  274. }
  275.  
  276.  
  277. /*-----------------------------------------------------------------------------
  278.  * Name:    DFclose
  279.  * Purpose: Write out updated DDs, close DF file
  280.  * Inputs:  dfile: pointer to open DF file
  281.  * Returns: 0 on success, -1 on failure with DFerror set
  282.  * Invokes: DFIcheck
  283.  * Users:   HDF programmers, many HDF user-level routines, utilities
  284.  *---------------------------------------------------------------------------*/
  285.  
  286. int DFclose( dfile)
  287. DF *dfile;
  288. {
  289.     DFdle *prev, *current;          /* DLEs being written out */
  290.     int i;
  291.  
  292.     DFerror = DFE_NOERROR;
  293.  
  294.     if ( DFIcheck(dfile))           /* is dfile a valid pointer? */
  295.         return(-1);
  296.  
  297.     if (dfile->type!=1) {           /* 0 is a closed file  or unused slot */
  298.         DFerror= DFE_NOTOPEN;
  299.         return(-1);
  300.     }
  301.  
  302.     prev=dfile->list;               /* start of DLE list */
  303.  
  304.     while (current=prev->next) {        /* for all DLEs */
  305.         if (dfile->changed) {           /* if file modified, write it out */
  306.                 /* current DD should be written at location prev->ddh.next */
  307.             CKSEEK( dfile->file, (long) prev->ddh.next,0, -1);
  308.             if (current->ddh.dds) {     /* if any DDs to write out */
  309. #ifdef DF_STRUCTOK
  310.                 CKWRITE( ¤t->ddh, sizeof(DFddh)+
  311.                     current->ddh.dds*sizeof(DFdd), 1, dfile->file, -1);
  312. #else /*DF_STRUCTOK*/
  313.                 {           /* write out dd struct elements */
  314.                     register  char *p;
  315.                     p = DFtbuf;
  316.                     INT16WRITE( p, current->ddh.dds);
  317.                     INT32WRITE( p, current->ddh.next);
  318.                     for (i=0; i<current->ddh.dds; i++) {
  319.                         UINT16WRITE( p, current->dd[i].tag);
  320.                         UINT16WRITE( p, current->dd[i].ref);
  321.                         INT32WRITE( p, current->dd[i].offset);
  322.                         INT32WRITE( p, current->dd[i].length);
  323.                     }
  324.                     CKWRITE( DFtbuf, 6+i*12, 1, dfile->file, -1);
  325.                             /* 6=size of DDH, 12=size of DD */
  326.                 }
  327. #endif /*DF_STRUCTOK*/
  328.             }
  329.         }
  330.         DFIfreespace((char*)prev);
  331.         prev=current;
  332.     }
  333.     DFIfreespace((char*)prev); /* get rid of the last one */
  334.  
  335.     if ( (DF_CLOSE( dfile->file)) !=0) {
  336.         DFerror = DFE_CANTCLOSE;
  337.         return(-1);
  338.     }
  339.  
  340.                     /* reset structure values */
  341.     dfile->last_ref= 0;
  342.     dfile->last_tag= 0;
  343.     dfile->type=0;
  344.     dfile->access=0;
  345.     dfile->file= 0;
  346.     dfile->list= (DFdle *) 0L;
  347.     DFinuse--;
  348.     return(0);
  349. }   
  350.  
  351.  
  352. /*-----------------------------------------------------------------------------
  353.  * Name:    DFIseedDDs
  354.  * Purpose: read DDs in file into memory
  355.  * Inputs:  dfile: pointer to open DF file
  356.  * Returns: 0 on success, -1 on failure with DFerror set
  357.  * Users:   HDF systems programmers, DFopen
  358.  *---------------------------------------------------------------------------*/
  359.  
  360. int DFIseedDDs(dfile)
  361. DF *dfile;
  362. {
  363.     DFdle *list;
  364.     DFddh ddh;
  365.     int i,n;                        /* n = no. of DDs in block */
  366.     
  367.     DFerror = DFE_NOERROR;
  368.  
  369.     if (dfile->list) {
  370.         DFerror = DFE_SEEDTWICE;    /* ### NOTE: Internal error! */
  371.         return(-1);
  372.     }
  373.     
  374.     dfile->list= (DFdle *) malloc(sizeof(DFdle)); /* includes one DD - unused */
  375.     CKMALLOC( dfile->list, -1);
  376.  
  377.     list=dfile->list;
  378.     list->next=NULL;                /* No other lists (yet) */
  379.     list->ddh.next= (int32)4L;      /* next is at 4 in file */
  380.     list->ddh.dds= -1;              /* flag so this is not written */
  381.  
  382.     DFmaxref = 0;                   /* largest ref found till now is 0 */
  383.  
  384.     while (list->ddh.next) {        /* while more headers to read */
  385.         CKSEEK( dfile->file, list->ddh.next, 0, -1);
  386.  
  387.                             /* read headers */
  388. #ifdef DF_STRUCTOK
  389.         CKREAD( &ddh, sizeof(DFddh), 1, dfile->file, -1);
  390. #else /*DF_STRUCTOK*/
  391.         {
  392.             register  char *p;
  393.             p = DFtbuf;
  394.             CKREAD( DFtbuf, 6, 1, dfile->file, -1);     /* 6 = size of header */
  395.             INT16READ( p, ddh.dds);
  396.             INT32READ( p, ddh.next);
  397.         }
  398. #endif /*DF_STRUCTOK*/
  399.         n   =ddh.dds;
  400.  
  401.     /* read in DDs */
  402.         list->next= (DFdle *)
  403.         DFIgetspace((unsigned)
  404.             (sizeof(DFdle)+ (n-1)* sizeof(DFdd)));
  405.                 /* note space for 1 DD included in DLE */
  406.         CKMALLOC( list->next, -1);
  407.         list=list->next;
  408.         list->next=NULL;
  409.     
  410.         DFmovmem((char*)&ddh, (char*)&(list->ddh),
  411.          sizeof(DFddh) ); /* Copy ddh */
  412.  
  413.         if (n) {
  414. #ifdef DF_STRUCTOK
  415.             CKREAD( &list->dd[0], sizeof(DFdd), n, dfile->file, -1);
  416.         /* load DD's */
  417. #else /*DF_STRUCTOK*/
  418.             {
  419.                 register  char *p;
  420.                 p = DFtbuf;
  421.                 CKREAD( DFtbuf, n*12, 1, dfile->file, -1);  /* 12=size of DD */
  422.                 for (i=0; i<n; i++) {
  423.                     UINT16READ( p, list->dd[i].tag);
  424.                     UINT16READ( p, list->dd[i].ref);
  425.                     INT32READ( p, list->dd[i].offset);
  426.                     INT32READ( p, list->dd[i].length);
  427.                 }
  428.             }
  429. #endif /*DF_STRUCTOK*/
  430.         }
  431.                 /* Remember highest ref found - ignore MTs */
  432.         for (i=0; i<n; i++)
  433.             if ((list->dd[i].ref > DFmaxref) && (list->dd[i].tag != DFTAG_MT))
  434.                                      DFmaxref = list->dd[i].ref;
  435.     }
  436.     return(0);
  437. }
  438.  
  439.  
  440. /*-----------------------------------------------------------------------------
  441.  * Name:    DFIcheck
  442.  * Purpose: check if dfile argument represents a valid DF file
  443.  * Inputs:  dfile: pointer to open DF file
  444.  * Returns: 0 on success, -1 on failure with DFerror set
  445.  * Users:   HDF systems programmers, several routines in this file
  446.  *---------------------------------------------------------------------------*/
  447.  
  448. int DFIcheck( dfile)
  449. DF *dfile;
  450. {
  451.     DFerror = DFE_NOERROR;
  452.     
  453.     if (!dfile) {
  454.         DFerror = DFE_DFNULL;
  455.         return(-1);
  456.         }
  457.  
  458.     if ((dfile->access & DFACC_ALL) != dfile->access)
  459.         DFerror = DFE_BADACC;
  460.  
  461.     if ((dfile->type >1) || (dfile->type <-1))
  462.         DFerror = DFE_ILLTYPE;
  463.  
  464.     if (!dfile->list)
  465.         DFerror= DFE_BADDDLIST;
  466.  
  467.     if (DFerror)
  468.         return(-1);
  469.     else
  470.         return(0);
  471.  
  472. }
  473.  
  474.  
  475. /*-----------------------------------------------------------------------------
  476.  * Name:    DFdescriptors
  477.  * Purpose: return a list of all the DDs in the file
  478.  * Inputs:  dfile: pointer to open DF file
  479.  *          ptr: pointer to space for the list of DDs
  480.  *          begin, num: the list starts at DD numbered begin, and contains
  481.  *              a maximum of num entries
  482.  * Returns: number of DDs returned in the list
  483.  * Invokes: DFIcheck
  484.  * Users:   HDF programmers, other routines and utilities
  485.  *---------------------------------------------------------------------------*/
  486.  
  487. int DFdescriptors(dfile, ptr, begin, num)
  488. DF *dfile;
  489. DFdesc ptr[];
  490. int begin, num;
  491. {
  492.     DFdle *DLEp;
  493.     int i,ddnum=0;
  494.  
  495.     if ( DFIcheck(dfile))
  496.         return(-1);
  497.     
  498.     if (begin<0) begin = 0;
  499.     if (num<0) num = 0;
  500.     ddnum = 0;
  501.     for (DLEp=dfile->list; DLEp; DLEp=DLEp->next)
  502.         for (i=0; i<DLEp->ddh.dds; i++, ddnum++)
  503.             if (ddnum>=begin) {
  504.                 if (ddnum<begin+num) {
  505.                     ptr[ddnum-begin] = DLEp->dd[i];
  506.                 }
  507.                 else
  508.                     return(num);
  509.             }
  510.     return(ddnum-begin);
  511. }
  512.  
  513.  
  514. /*-----------------------------------------------------------------------------
  515.  * Name:    DFnumber
  516.  * Purpose: return the number of occurrences of the given tag in the HDF file
  517.  * Inputs:  dfile: pointer to open DF file
  518.  *          tag: tag to count occurrences of
  519.  * Returns: number of occurrences of tag in file, -1 on error with DFerror set
  520.  *          if tag is DFTAG_WILDCARD, count occurrences of all tags
  521.  * Invokes: DFIcheck
  522.  * Users:   HDF programmers, other routines and utilities
  523.  *---------------------------------------------------------------------------*/
  524.  
  525. int DFnumber(dfile, tag)
  526. DF *dfile;
  527. uint16 tag;
  528. {
  529.     DFdle *DLEp;
  530.     int i, ntag=0;
  531.  
  532.     if ( DFIcheck(dfile))
  533.         return(-1);
  534.     
  535.     for (DLEp=dfile->list; DLEp; DLEp=DLEp->next)
  536.         if (tag==DFTAG_WILDCARD) ntag += DLEp->ddh.dds;
  537.         else {
  538.             for (i=0; i<DLEp->ddh.dds; i++)
  539.                 if (DLEp->dd[i].tag == tag) ntag++;
  540.         }
  541.  
  542.     return(ntag);
  543. }
  544.  
  545.  
  546. /*-----------------------------------------------------------------------------
  547.  * Name:    DFsetfind
  548.  * Purpose: set up parameters for a wildcard find
  549.  * Inputs:  dfile: pointer to open DF file
  550.  *          tag, ref: tag and ref of element to search for, 0 is wildcard
  551.  * Returns: 0 on success, -1 on failure
  552.  * Invokes: DFIcheck
  553.  * Users:   HDF programmers, several utilities
  554.  *---------------------------------------------------------------------------*/
  555.  
  556. int DFsetfind( dfile, tag, ref)
  557. DF *dfile;
  558. uint16 tag,ref;
  559. {
  560.  
  561.     if ( DFIcheck(dfile))
  562.         return(-1);
  563.     
  564.         /* remember tag, ref for subsequent searches */
  565.     dfile->last_tag=tag;
  566.     dfile->last_ref=ref;
  567.     dfile->last_dle=NULL;           /* flag value: nothing found so far */
  568.  
  569.     return(0);
  570. }
  571.     
  572.  
  573. /*-----------------------------------------------------------------------------
  574.  * Name:    DFfind
  575.  * Purpose: perform wildcard searches - sets up parameters, calls DFIfind
  576.  * Inputs:  dfile: pointer to open DF file
  577.  *          ptr: ptr to put in DD when found
  578.  * Returns: 0 on success, -1 on failure
  579.  *          if success, DD matching specification is copied to *ptr
  580.  * Invokes: DFIcheck, DFIfind
  581.  * Users:   HDF programmers, several utilities
  582.  *---------------------------------------------------------------------------*/
  583.  
  584. int DFfind(dfile, ptr)
  585. DF *dfile;
  586. struct DFdesc *ptr;
  587. {
  588.     DFdle *cDLEp;
  589.     int cdd;
  590.     uint16 tag, ref, ltag,lref;
  591.     int isfirst=1;
  592.  
  593.     if ( DFIcheck(dfile))
  594.         return(-1);
  595.  
  596.     DFerror = DFE_NOERROR;
  597.  
  598.     tag = dfile->last_tag;          /* tag, ref being searched for */
  599.     ref = dfile->last_ref;
  600.  
  601.     if (dfile->last_dle) {          /* something found previously */
  602.         isfirst = 0;
  603.         ltag= dfile->last_dle->dd[ dfile->last_dd ].tag;    /* prev tag, ref */
  604.         lref= dfile->last_dle->dd[ dfile->last_dd ].ref;
  605.     } else {
  606.     ltag = lref = 0;
  607.     }
  608.  
  609.     if ((tag!=DFTAG_NULL) &&        /* empty DDs are invisible on finds */
  610.         !DFIfind( dfile, tag, ref, isfirst, ltag, lref, &cDLEp, &cdd)) {
  611.         *ptr = cDLEp->dd[cdd];      /* if found, copy dd to ptr */
  612.         dfile->last_dd = cdd;       /* set last_dle and last_dd to DD found */
  613.         dfile->last_dle= cDLEp;
  614.         return(0);
  615.     } else {
  616.         DFerror = DFE_NOMATCH;
  617.         ptr->tag = 0;
  618.         ptr->ref = 0;
  619.         return(-1);
  620.     }
  621. }
  622.         
  623.  
  624. /*-----------------------------------------------------------------------------
  625.  * Name:    DFIfind
  626.  * Purpose: perform wildcard searches
  627.  * Inputs:  dfile: pointer to open DF file
  628.  *          tag, ref: tag, ref (possibly wildcard) being searched for
  629.  *          isfirst: 1 if first call to DFIfind for this tag/ref, else 0
  630.  *          ltag, lref: last tag and ref returned for this search,
  631.  *              don't care if isfirst set
  632.  *          cDLEp, cddp: pointers to DLE and DD number to return matched DD in
  633.  * Returns: 0 on success, -1 on failure
  634.  *          if success, cDLEp and cddp are set to point to matched DD
  635.  * Users:   HDF system programmers, DFfind, HDF utilities, many routines
  636.  * Remarks: The searching algorithm is a little complex.  It returns entries
  637.  *          in the sorting order of refs, then tags.  Even after a candidate
  638.  *          is found, searching continues till best candidate found.  Best way
  639.  *          to check if conditions: work it out independently for yourself!
  640.  *---------------------------------------------------------------------------*/
  641.  
  642. int DFIfind( dfile, tag, ref, isfirst, ltag, lref, cDLEp, cddp)
  643. DF *dfile;
  644. DFdle **cDLEp;
  645. int *cddp;
  646. int isfirst;                            /* 1 if no prev search, 0 otherwise */
  647. uint16 tag, ref, ltag, lref;
  648. {
  649.     DFdle *DLEp;
  650.     int i, found=0;
  651.     uint16 ctag=0, cref=0, wtag,wref; /* ctag, cref: tag, ref found so far */
  652.                                       /* wtag, wref: tag, ref being checked */
  653.  
  654.     DLEp=dfile->list;               /* start of DLE list */
  655.  
  656.     if (tag && ref) {               /* No wildcards */
  657.         if (isfirst) {              /* if not already found */
  658.             while (DLEp) {          /* go through list */
  659.                 for (i=0; i<DLEp->ddh.dds; i++) {       /* for all DDs */
  660.                     if (DLEp->dd[i].tag==tag &&
  661.                             DLEp->dd[i].ref==ref)
  662.                         {*cDLEp=DLEp; *cddp=i; return(0);}
  663.                     }
  664.                 DLEp=DLEp->next;
  665.                 }
  666.             }
  667.         }
  668.     else if (tag && !ref)           /* wildcard ref */
  669.         while (DLEp) {
  670.             for (i=0; i<DLEp->ddh.dds; i++) {
  671.                 wtag=DLEp->dd[i].tag;
  672.                 wref=DLEp->dd[i].ref;
  673.         /* condition = tag match, better than found so far (if any),
  674.             follows what was returned last time (if any) */
  675.                 if ( (wtag==tag) && (!found || (wref<cref)) &&
  676.                     (isfirst || (wref>lref)))
  677.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  678.                 }
  679.             DLEp=DLEp->next;
  680.             }
  681.     else if (!tag && ref)           /* wildcard tag */
  682.         while (DLEp) {
  683.             for (i=0; i<DLEp->ddh.dds; i++) {
  684.                 wtag=DLEp->dd[i].tag;
  685.                 wref=DLEp->dd[i].ref;
  686.                 if ((wref==ref) && (isfirst || (wtag>ltag)) &&
  687.                     (!found || (wtag<ctag)) )
  688.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  689.                 }
  690.             DLEp=DLEp->next;
  691.             }
  692.     else if (!tag && !ref)          /* wildcard tag & ref */
  693.         while (DLEp) {
  694.             for (i=0; i<DLEp->ddh.dds; i++) {
  695.                 wtag=DLEp->dd[i].tag;
  696.                 wref=DLEp->dd[i].ref;
  697.                 if ((isfirst || (wref>lref) || (wref==lref && wtag>ltag)) &&
  698.                     (!found || (wref<cref) || (wref==cref && wtag<ctag)) &&
  699.                     (wtag!=DFTAG_NULL))         /* empty DDs are invisible */
  700.                     { ctag=wtag; cref=wref; *cDLEp=DLEp; *cddp=i;found=1;}
  701.                 }
  702.             DLEp=DLEp->next;
  703.             }
  704.     return(found-1);            /* 0 or -1 */
  705. }
  706.  
  707.  
  708. /*-----------------------------------------------------------------------------
  709.  * Name:    DFIemptyDD
  710.  * Purpose: find an empty DD to use, or create a block of DDs if necessary
  711.  * Inputs:  dfile: pointer to open DF file
  712.  * Returns: pointer to an empty DD
  713.  * Invokes: DFIfind
  714.  * Users:   HDF system programmers, DFaccess, DFdup
  715.  *---------------------------------------------------------------------------*/
  716.  
  717. DFdd *DFIemptyDD(dfile)
  718. DF *dfile;
  719. {
  720.     DFdle *cDLEp;
  721.     int cdd;
  722.  
  723.     if (!DFIfind( dfile, DFTAG_NULL, DFREF_WILDCARD, 1, 0, 0, &cDLEp, &cdd))
  724.         return(&(cDLEp->dd[cdd]));      /* there is an empty DD */
  725.  
  726.     else {          /* add new DDH block */
  727.         int32 fpos;
  728.         DFdle *p, *dle;
  729.         DFddh ddh;
  730.         DFdd dd;
  731.         int j;
  732.  
  733.         CKSEEKEND( dfile->file, (long) 0, 2, NULL); /* go to end of df */
  734.         fpos= (int32) DF_TELL(dfile->file);
  735.         ddh.dds= dfile->defdds;             /* Initialize ddh */
  736.         ddh.next= 0;
  737.         dd.tag=DFTAG_NULL;                  /* and all DD's */
  738.         dd.ref=0;
  739. #ifdef DF_STRUCTOK
  740.         CKWRITE( &ddh, sizeof(DFddh), 1, dfile->file, NULL);
  741. #else /*DF_STRUCTOK*/
  742.         {
  743.             register  char *p;
  744.             p = DFtbuf;
  745.             INT16WRITE( p, ddh.dds);
  746.             INT32WRITE( p, ddh.next);
  747.             CKWRITE( DFtbuf, 6, 1, dfile->file, NULL);  /* 6 = size of header */
  748.         }
  749. #endif /*DF_STRUCTOK*/
  750.         for (j=0; j<ddh.dds; j++) {
  751. #ifdef DF_STRUCTOK
  752.             CKWRITE( &dd, sizeof(DFdd),1, dfile->file, NULL);
  753. #else /*DF_STRUCTOK*/
  754.             {
  755.                 register  char *p;
  756.                 p = DFtbuf;
  757.                 UINT16WRITE( p, dd.tag);
  758.                 UINT16WRITE( p, dd.tag);
  759.                 INT32WRITE( p, dd.offset);
  760.                 INT32WRITE( p, dd.length);
  761.                 CKWRITE( DFtbuf, 12, 1, dfile->file, NULL); /* 12=size of dd */
  762.             }
  763. #endif /*DF_STRUCTOK*/
  764.         }
  765.  
  766.         p=dfile->list;                      /* find end of list */
  767.         while (p->next) p= p->next;
  768.  
  769.         p->ddh.next=fpos;                   /* new dd goes at end of file */
  770.         dle=(DFdle *)
  771.         DFIgetspace((unsigned)
  772.             (sizeof(DFdle)+(ddh.dds-1)*sizeof(DFdd)));
  773.                             /* one dd included in dle */
  774.         CKMALLOC(dle, NULL);
  775.         p->next=dle;                        /* insert dle at end of list */
  776.         dle->next=NULL;
  777.         DFmovmem((char*)&ddh, (char*)&dle->ddh,sizeof(DFddh));
  778.         for (j=0; j<ddh.dds; j++)
  779.             DFmovmem( (char*)&dd, (char*)&dle->dd[j], sizeof(DFdd));
  780.         return(&(dle->dd[0]));
  781.     }
  782. #ifdef PC
  783.     return(NULL);           /* dummy, for return value checking */
  784. #endif /*PC*/
  785. }
  786.  
  787.  
  788. /*-----------------------------------------------------------------------------
  789.  * Name:    DFaccess
  790.  * Purpose: set up read/write access to a data element
  791.  * Inputs:  dfile: pointer to open DF file
  792.  *          tag, ref: id of element
  793.  *          access: "r", "w", "a" (append)
  794.  * Returns: 0 on success, -1 on failure
  795.  * Invokes: DFIcheck, DFIfind, DFIemptyDD
  796.  * Users:   HDF programmers, utilities, DFgetelement, DFputelement
  797.  * Remarks: if "a", data element will be copied to end of file, since it
  798.  *          cannot be extended in place if it is in the middle of the file
  799.  *---------------------------------------------------------------------------*/
  800.  
  801. int DFaccess(dfile, tag, ref, access)
  802. DF *dfile;
  803. uint16 tag, ref;
  804. char *access;
  805. {
  806.     DFdle *cDLEp;
  807.     int cdd;
  808.      char *storage=NULL;        /* for copying data if append access */
  809.     char accmode;
  810.     
  811.     DFerror = DFE_NOERROR;
  812.  
  813.     if (DFIcheck(dfile) )
  814.         return( -1);
  815.  
  816.     if (!tag) {
  817.         DFerror = DFE_BADTAG;
  818.         return(-1);
  819.     }
  820.     if (!ref) {
  821.         DFerror = DFE_BADREF;
  822.         return(-1);
  823.     }
  824.             /* set up and check access modes */
  825.     accmode = *access;
  826.     switch (accmode) {
  827.         case 'r':   dfile->up_access = DFACC_READ;  break;
  828.         case 'a':
  829.         case 'w':   dfile->up_access = DFACC_WRITE; break;
  830.         default:    DFerror = DFE_BADACC;   return(-1); 
  831.     }
  832.     if ((dfile->up_access & dfile->access) != dfile->up_access) {
  833.         DFerror = DFE_BADACC;
  834.         return(-1);
  835.     }
  836.                     
  837.                 /* Find DD of element to be updated */
  838.     if (!DFIfind( dfile, tag, ref, 1, 0 , 0, &cDLEp, &cdd))
  839.         dfile->up_dd = &(cDLEp->dd[cdd]);   /* DD of element to be updated */
  840.  
  841.     else {              /* No such DD */
  842.         if (accmode=='r') {
  843.             DFerror = DFE_NOMATCH; 
  844.             return(-1);
  845.         }
  846.         accmode = 'w';          /* append is really write if no current data */
  847.         dfile->up_dd = DFIemptyDD(dfile);       /* find an empty DD to use */
  848.         if (!dfile->up_dd) return(-1);
  849.         dfile->up_dd->tag = tag;                    /* fill in DD block */
  850.         dfile->up_dd->ref = ref;
  851.         dfile->up_dd->length = 0;
  852.     }
  853.  
  854.     if (accmode!='w') {        /*for read, DFaccess positions fp at element */
  855.                                 /* for append also, we need to read element */
  856.         CKSEEK(dfile->file, (long) dfile->up_dd->offset, 0, -1);
  857.         }
  858.     else dfile->up_dd->length = 0;  /* throws away any existing data */
  859.  
  860.     if (accmode!='r') {
  861.         dfile->changed = 1;         /* if write/append, file modified */
  862.  
  863.         if ((accmode=='a') && (dfile->up_dd->length)) {
  864.                     /* allocate storage to read current data */
  865.                 storage = (char*)DFIgetspace((unsigned)(dfile->up_dd->length));
  866.                 CKMALLOC( storage, -1 );
  867.                 CKREAD( storage, dfile->up_dd->length, 1, dfile->file, -1);
  868.         }
  869.  
  870.         CKSEEKEND( dfile->file, (long) 0, 2, -1);   /* go to end of df */
  871.             /* find the offset of the end of file */
  872.         dfile->up_dd->offset = (int32) DF_TELL(dfile->file);
  873.  
  874.         if ((accmode=='a') && dfile->up_dd->length) {   /* copy old data */
  875.             CKWRITE( storage, dfile->up_dd->length, 1, dfile->file, -1);
  876.                 /* note this leaves fp positioned correctly for write */
  877.         }
  878.         if (storage) DFIfreespace(storage);
  879.     }
  880.  
  881.     if (DFmaxref < ref) DFmaxref = ref;                 /* note ref is used */
  882.     if (DFreflist) DFreflist[ref/8] |= patterns[ref%8]; /* set ref'th bit */
  883.  
  884.     return(0);
  885. }
  886.  
  887.  
  888. /*-----------------------------------------------------------------------------
  889.  * Name:    DFstart
  890.  * Purpose: set up read/write access to a data element - alternate to DFaccess
  891.  * Inputs:  dfile: pointer to open DF file
  892.  *          tag, ref: id of element
  893.  *          access: "r", "w", "a" (append)
  894.  * Returns: 0 on success, -1 on failure
  895.  * Invokes: DFaccess
  896.  * Users:   Accidental/old-time users, intending to use DFaccess
  897.  * Remarks: none
  898.  *---------------------------------------------------------------------------*/
  899.  
  900. int DFstart(dfile, tag, ref, access)
  901. DF *dfile;
  902. uint16 tag, ref;
  903. char *access;
  904. {
  905.  
  906.     return(DFaccess(dfile, tag, ref, access));
  907. }
  908.         
  909.  
  910. /*-----------------------------------------------------------------------------
  911.  * Name:    DFread
  912.  * Purpose: read bytes from DF file (part of element specified by DFaccess)
  913.  * Inputs:  dfile: pointer to open DF file
  914.  *          ptr: pointer to space to read data into
  915.  *          len: number of bytes to read
  916.  * Returns: number of bytes read on success, -1 on failure
  917.  * Invokes: DFIcheck
  918.  * Users:   HDF programmers, DFgetelement
  919.  *---------------------------------------------------------------------------*/
  920.  
  921. int32 DFread( dfile, ptr, len)
  922. DF *dfile;
  923. char *ptr;
  924. int32 len;
  925. {
  926.     int32 maxlen;
  927. #ifdef VMS
  928.     int32 totalread;
  929.     int32 readsize;
  930. #endif /*VMS*/
  931.  
  932.     DFerror = DFE_NOERROR;
  933.  
  934.     if (DFIcheck(dfile) )
  935.         return( (int32) -1);
  936.  
  937.     if (!dfile->up_dd) {
  938.         DFerror = DFE_BADCALL;
  939.         return((int32) -1);
  940.     }
  941.  
  942.     if (!(dfile->up_access & DFACC_READ)) {
  943.         DFerror = DFE_BADACC;
  944.         return((int32) -1);
  945.     }
  946.  
  947.     if (!ptr) {
  948.         DFerror = DFE_BADPTR;
  949.         return((int32) -1);
  950.     }
  951.  
  952.     maxlen = dfile->up_dd->length -
  953.                 ((int32) DF_TELL(dfile->file) - dfile->up_dd->offset);
  954.     if (len>maxlen) len = maxlen;
  955.     if (len<0) {            /* will also catch reads from beyond element */
  956.         DFerror = DFE_BADLEN;
  957.         return(-1);
  958.     }
  959.  
  960. #ifdef VMS
  961.     totalread = 0;
  962.     while (totalread<len) {
  963.         readsize = len - totalread;
  964.         if (readsize>512) readsize = 512;
  965.         CKREAD( &ptr[totalread], (int)readsize, 1, dfile->file, -1); 
  966.         totalread += readsize;
  967.     }
  968.         
  969. #else /*VMS*/
  970.     if (len) {      /* NOTE: cast to (int) will limit to 64K on 16 bit m/cs */
  971.         CKREAD( ptr, (int) len, 1, dfile->file, -1); 
  972.     }
  973. #endif /*VMS*/
  974.  
  975.     return(len);
  976. }
  977.  
  978.  
  979. /*-----------------------------------------------------------------------------
  980.  * Name:    DFseek
  981.  * Purpose: seek to a position, within element specified by DFaccess
  982.  * Inputs:  dfile: pointer to open DF file
  983.  *          offset: offset from beginning of element
  984.  * Returns: offset of actual position seek'ed to from beginning of element
  985.  * Invokes: DFIcheck
  986.  * Users:   HDF programmers
  987.  *---------------------------------------------------------------------------*/
  988.  
  989. int32 DFseek( dfile, offset)
  990. DF *dfile;
  991. int32 offset;
  992. {
  993.     
  994.     DFerror = DFE_NOERROR;
  995.  
  996.     if (DFIcheck(dfile) )
  997.         return( -1);
  998.  
  999.     if (!dfile->up_dd) {
  1000.         DFerror = DFE_BADCALL;
  1001.         return(-1);
  1002.     }
  1003.  
  1004.     if (!(dfile->up_access & DFACC_READ)) {
  1005.         DFerror = DFE_BADACC;
  1006.         return(-1);
  1007.     }
  1008.  
  1009.     if (offset > dfile->up_dd->length) {
  1010.         offset = dfile->up_dd->length;
  1011.         DFerror = DFE_BADSEEK;
  1012.     }
  1013.  
  1014.     CKSEEK( dfile->file, (long) dfile->up_dd->offset + offset, 0, -1);
  1015.     return(offset);
  1016. }
  1017.  
  1018.  
  1019. /*-----------------------------------------------------------------------------
  1020.  * Name:    DFwrite
  1021.  * Purpose: write bytes to DF file (part of element specified by DFaccess)
  1022.  * Inputs:  dfile: pointer to open DF file
  1023.  *          ptr: pointer to data to be written
  1024.  *          len: number of bytes to written
  1025.  * Returns: number of bytes written on success, -1 on failure
  1026.  * Invokes: DFIcheck
  1027.  * Users:   HDF programmers, DFputelement
  1028.  *---------------------------------------------------------------------------*/
  1029.  
  1030. int32 DFwrite( dfile, ptr, len)
  1031. DF *dfile;
  1032. char *ptr;
  1033. int32 len;
  1034. {
  1035. #ifdef VMS
  1036.     int32 totalwritten;
  1037.     int32 writesize;
  1038. #endif /*VMS*/
  1039.  
  1040.     DFerror = DFE_NOERROR;
  1041.  
  1042.     if (DFIcheck(dfile) )
  1043.         return( -1);
  1044.  
  1045.     if (!(dfile->up_dd)) {
  1046.         DFerror = DFE_BADCALL;
  1047.         return(-1);
  1048.     }
  1049.  
  1050.     if (!(dfile->up_access & DFACC_WRITE)) {
  1051.         DFerror = DFE_RDONLY;
  1052.         return(-1);
  1053.     }
  1054.  
  1055.     if (!ptr) {
  1056.         DFerror = DFE_BADPTR;
  1057.         return(-1);
  1058.     }
  1059.  
  1060.     if (len<0) {
  1061.         DFerror = DFE_BADLEN;
  1062.         return(-1);
  1063.     }
  1064.  
  1065.     if (!(dfile->changed)) {        /* if an update between writes, re-seek */
  1066.       CKSEEK( dfile->file, (long) dfile->up_dd->offset + dfile->up_dd->length,
  1067.             0, -1);
  1068.     }
  1069.  
  1070. #ifdef VMS
  1071.     totalwritten = 0;
  1072.     while (totalwritten<len) {
  1073.         writesize = len - totalwritten;
  1074.         if (writesize>512) writesize = 512; /* write at most 512 at a time */
  1075.         CKWRITE( &ptr[totalwritten], (int)writesize, 1, dfile->file, -1); 
  1076.         totalwritten += writesize;
  1077.     }
  1078. #else /*VMS*/
  1079.     if (len) { CKWRITE( ptr, len, 1, dfile->file, -1); }
  1080. #endif /*VMS*/
  1081.     dfile->up_dd->length += len;
  1082.     return(len);
  1083. }
  1084.  
  1085.  
  1086. /*-----------------------------------------------------------------------------
  1087.  * Name:    DFupdate
  1088.  * Purpose: write out updated DD blocks to file
  1089.  * Inputs:  dfile: pointer to open DF file
  1090.  * Returns: 0 on success, -1 on failure
  1091.  * Invokes: DFIcheck
  1092.  * Users:   HDF programmers
  1093.  *---------------------------------------------------------------------------*/
  1094.  
  1095. int DFupdate( dfile)
  1096. DF *dfile;
  1097. {
  1098.     DFdle *prev, *current;
  1099.     int i;
  1100.  
  1101.     DFerror = DFE_NOERROR;
  1102.  
  1103.     if ( DFIcheck(dfile))
  1104.         return(-1);
  1105.  
  1106.     if (dfile->type!=1) {
  1107.         DFerror= DFE_NOTOPEN;
  1108.         return(-1);
  1109.     }
  1110.  
  1111.     prev=dfile->list;           /* start of DLE list */
  1112.  
  1113.     if (dfile->changed) {           /* modified */
  1114.         while (current=prev->next) {
  1115.             CKSEEK( dfile->file, (long) prev->ddh.next,0, -1);
  1116.             if (current->ddh.dds) {
  1117. #ifdef DF_STRUCTOK
  1118.                 CKWRITE( ¤t->ddh, sizeof(DFddh) +
  1119.                     (current->ddh.dds*sizeof(DFdd)), 1, dfile->file, -1);
  1120. #else /*DF_STRUCTOK*/
  1121.                 {
  1122.                     register  char *p;
  1123.                     p = DFtbuf;
  1124.                     INT16WRITE( p, current->ddh.dds);
  1125.                     INT32WRITE( p, current->ddh.next);
  1126.                     for (i=0; i<current->ddh.dds; i++) {
  1127.                         UINT16WRITE( p, current->dd[i].tag);
  1128.                         UINT16WRITE( p, current->dd[i].ref);
  1129.                         INT32WRITE( p, current->dd[i].offset);
  1130.                         INT32WRITE( p, current->dd[i].length);
  1131.                     }
  1132.                     CKWRITE( DFtbuf, 6+i*12, 1, dfile->file, -1);
  1133.                         /* 6= size of DDH, 12=size of DD */
  1134.                 }
  1135. #endif /*DF_STRUCTOK*/
  1136.             }
  1137.             prev=current;
  1138.         }
  1139.         DF_FLUSH(dfile->file);              /* ensure everything is written */
  1140.     }
  1141.     dfile->changed=0;
  1142.     return(0);
  1143. }   
  1144.  
  1145.  
  1146. /*-----------------------------------------------------------------------------
  1147.  * Name:    DFstat
  1148.  * Purpose: provide status information about DF file
  1149.  * Inputs:  dfile: pointer to open DF file
  1150.  *          dfinfo: ptr to space where to place information on HDF file
  1151.  * Returns: 0 on success, -1 on failure
  1152.  * Invokes: DFIcheck
  1153.  * Users:   HDF programmers
  1154.  *---------------------------------------------------------------------------*/
  1155.  
  1156. int DFstat(dfile, dfinfo)
  1157. DF *dfile;
  1158. struct DFdata *dfinfo;
  1159. {
  1160.  
  1161.     DFerror = DFE_NOERROR;
  1162.  
  1163.     if (DFIcheck(dfile) )
  1164.         return( -1);
  1165.  
  1166.         /* This is version number of program.  More will be added later */
  1167.     dfinfo->version = DFVERSION;
  1168.     return(0);
  1169. }
  1170.     
  1171.  
  1172. /*-----------------------------------------------------------------------------
  1173.  * Name:    DFgetelement
  1174.  * Purpose: read a data element from df file
  1175.  * Inputs:  dfile: pointer to open DF file
  1176.  *          tag, ref: id of data element
  1177.  *          ptr: space to put data element in
  1178.  * Returns: number of bytes read on success, -1 on failure
  1179.  * Invokes: DFaccess, DFread
  1180.  * Users:   HDF programmers, utilities, many other routines
  1181.  *---------------------------------------------------------------------------*/
  1182.  
  1183. int32 DFgetelement( dfile, tag, ref, ptr)
  1184. DF *dfile;
  1185. uint16 tag, ref;
  1186. char *ptr;
  1187. {
  1188.     if ( DFaccess( dfile, tag, ref, "r")<0) return((int32) -1);
  1189.     return( DFread( dfile, ptr, (int32) dfile->up_dd->length));
  1190. }
  1191.  
  1192.  
  1193. /*-----------------------------------------------------------------------------
  1194.  * Name:    DFputelement
  1195.  * Purpose: write a data element to df file
  1196.  * Inputs:  dfile: pointer to open DF file
  1197.  *          tag, ref: id of data element
  1198.  *          ptr: pointer to data element to be written
  1199.  *          len: length of data element
  1200.  * Returns: 0 on success, -1 on failure
  1201.  * Invokes: DFaccess, DFwrite
  1202.  * Users:   HDF programmers, utilities, many other routines
  1203.  *---------------------------------------------------------------------------*/
  1204.  
  1205. int DFputelement( dfile, tag, ref, ptr, len)
  1206. DF *dfile;
  1207. uint16 tag, ref;
  1208.  char *ptr;
  1209. int32 len;
  1210. {
  1211.     if ( DFaccess( dfile, tag, ref, "w")<0) return(-1);
  1212.     if( DFwrite( dfile, ptr, len)<0) return(-1);
  1213.     return(0);
  1214. }
  1215.  
  1216.  
  1217. /*-----------------------------------------------------------------------------
  1218.  * Name:    DFdup
  1219.  * Purpose: Add a new tag/ref for existing data
  1220.  * Inputs:  dfile: pointer to open DF file
  1221.  *          itag, iref: new id of data element
  1222.  *          otag, oref: current id of data element
  1223.  * Returns: 0 on success, -1 on failure
  1224.  * Invokes: DFIcheck, DFIfind, DFIemptyDD
  1225.  * Users:   HDF programmers, utilities, many other routines
  1226.  *---------------------------------------------------------------------------*/
  1227.  
  1228. int DFdup(dfile, itag, iref, otag, oref)
  1229. DF *dfile;
  1230. uint16 itag, iref, otag, oref;  /* new, existing tag/refs */
  1231. {
  1232.     DFdle *odlep, *idlep;
  1233.     int ocdd, icdd;
  1234.     DFdd *newdd;
  1235.  
  1236.     DFerror = DFE_NOERROR;
  1237.  
  1238.     if (DFIcheck(dfile) )
  1239.         return( -1);
  1240.  
  1241.     if (DFIfind( dfile, otag, oref, 1, 0, 0, &odlep, &ocdd)<0) {
  1242.         DFerror = DFE_NOMATCH;      /* existing tag/ref does not exist! */
  1243.         return(-1);
  1244.     }
  1245.  
  1246.     if (!DFIfind( dfile, itag, iref, 1, 0, 0, &idlep, &icdd))
  1247.         newdd = &idlep->dd[icdd];   /* replaces existing DD */
  1248.     else {
  1249.         newdd = DFIemptyDD(dfile);  /* find empty DD */
  1250.         if (!newdd) return(-1);
  1251.         newdd->tag = itag;
  1252.         newdd->ref = iref;
  1253.  
  1254.         if (DFmaxref < iref) DFmaxref = iref;       /* mark iref as used */
  1255.         if (DFreflist) DFreflist[iref/8] |= patterns[iref%8];
  1256.     }
  1257.     newdd->offset = odlep->dd[ocdd].offset;
  1258.     newdd->length = odlep->dd[ocdd].length;
  1259.     dfile->changed = 1;
  1260.     return(0);
  1261. }
  1262.  
  1263.  
  1264. /*-----------------------------------------------------------------------------
  1265.  * Name:    DFdel
  1266.  * Purpose: Delete a data element from file
  1267.  * Inputs:  dfile: pointer to open DF file
  1268.  *          tag, ref: id of data element
  1269.  * Returns: 0 on success, -1 on failure
  1270.  * Invokes: DFIcheck, DFIfind
  1271.  * Users:   HDF programmers, utilities, many other routines
  1272.  * Remarks: Data element is not deleted, only the reference to it is changed
  1273.  *---------------------------------------------------------------------------*/
  1274.  
  1275. int DFdel(dfile, tag, ref)
  1276. DF *dfile;
  1277. uint16 tag, ref;
  1278. {
  1279.     DFdle *dlep;
  1280.     int cdd;
  1281.  
  1282.     DFerror = DFE_NOERROR;
  1283.  
  1284.     if (DFIcheck(dfile) )
  1285.         return( -1);
  1286.  
  1287.     if (DFIfind( dfile, tag, ref, 1, 0, 0, &dlep, &cdd)<0) {
  1288.         DFerror = DFE_NOMATCH;      /* nothing to delete */
  1289.         return(-1);
  1290.     }
  1291.     dlep->dd[cdd].tag = DFTAG_NULL;
  1292.     dlep->dd[cdd].ref = 0;
  1293.     dfile->changed = 1;
  1294.     return(0);
  1295. }
  1296.  
  1297.  
  1298. /*-----------------------------------------------------------------------------
  1299.  * Name:    DFnewref
  1300.  * Purpose: Get an ununsed reference number
  1301.  * Inputs:  dfile: pointer to HDF file
  1302.  * Returns: unused ref number if found.  0 with DFerror set if not.
  1303.  * Users:   HDF programmers, for adding data elements
  1304.  * Invokes: DFIcheck
  1305.  * Remarks: Currently, returns a ref which is not used with any tag, except
  1306.  *          possibly DFTAG_MT
  1307.  *---------------------------------------------------------------------------*/
  1308.  
  1309. uint16 DFnewref(dfile)
  1310. DF *dfile;
  1311. {
  1312.     DFdle *DLEp;
  1313.     int i,j;
  1314.  
  1315.     DFerror = DFE_NOERROR;
  1316.  
  1317.     if (DFIcheck(dfile) )
  1318.         return ((uint16) 0);
  1319.  
  1320.     if (DFmaxref < 65535)       /* 65535 = largest 16-bit uint = largest ref */
  1321.         return(++DFmaxref);
  1322.  
  1323.     /* allocate a bit array of 65536 bits - one for each ref */
  1324.     if (DFreflist==NULL) {
  1325.         if ((DFreflist = (unsigned char *) DFIgetspace(8192)) == NULL)
  1326.                 return((uint16) 0);             /* 8192 = 65536/8 */
  1327.         
  1328.         for (i=1; i<8192; i++) DFreflist[i] = 0;    /* initialize */
  1329.         DFreflist[0] = 0x80;            /* ref 0 is not to be allocated */
  1330.  
  1331.         for (DLEp=dfile->list; DLEp; DLEp=DLEp->next) /* go through all DDs */
  1332.             for (i=0; i<DLEp->ddh.dds; i++)
  1333.                 if (DLEp->dd[i].tag != DFTAG_MT)    /* set ref'th bit to 1 */
  1334.                     DFreflist[DLEp->dd[i].ref/8] |=
  1335.             patterns[DLEp->dd[i].ref%8];
  1336.     }
  1337.  
  1338.     for (i=0; i<8192; i++)
  1339.         if (DFreflist[i] != 0xff) break; /* if ff, all refs taken */
  1340.  
  1341.     if (i==8192) {
  1342.         DFerror = DFE_NOREF;
  1343.         return((uint16) 0);
  1344.     }
  1345.  
  1346.     for (j=0; j<8; j++) {
  1347.         if (!(DFreflist[i] & patterns[j])) { /* ref j is not allocated */
  1348.             DFreflist[i] |= patterns[j]; /* ref j is now in use */
  1349.             return((uint16) (i*8 + j));    /* ref to use */
  1350.         }
  1351.     }
  1352.  
  1353.     return((uint16) 0);        /* this statement should not be reached */
  1354. }
  1355.  
  1356.  
  1357. /*-----------------------------------------------------------------------------
  1358.  * Name:    DFishdf
  1359.  * Purpose: Is this an HDF file?
  1360.  * Inputs:  filename: name of HDF file
  1361.  * Returns: 0 if it is an HDF file, -1 if not.  DFerror is set to open error
  1362.  *              if any, else to DFE_NOERROR
  1363.  * Users:   HDF systems programmers, for checking files
  1364.  * Invokes: DFopen, DFclose
  1365.  * Remarks: none
  1366.  *---------------------------------------------------------------------------*/
  1367.  
  1368. DFishdf(filename)
  1369. char *filename;
  1370. {
  1371.     DF *dfile;
  1372.  
  1373.     DFerror = DFE_NOERROR;
  1374.  
  1375.     dfile = DFopen(filename, DFACC_READ, -1);
  1376.     if (dfile==NULL) return(-1);
  1377.     return(DFclose(dfile));
  1378. }
  1379.  
  1380.  
  1381. /*-----------------------------------------------------------------------------
  1382.  * Name:    DFerrno
  1383.  * Purpose: return value of DFerror
  1384.  * Inputs:  none
  1385.  * Returns: value of DFerror
  1386.  * Users:   HDF users, programmers
  1387.  * Invokes: none
  1388.  * Remarks: none
  1389.  *---------------------------------------------------------------------------*/
  1390.  
  1391. int DFerrno()
  1392. {
  1393.  
  1394.     return(DFerror);
  1395. }
  1396.  
  1397.  
  1398. /*-----------------------------------------------------------------------------
  1399.  * Name:    DFIerr
  1400.  * Purpose: Close a file and return on error. save DFerror
  1401.  * Inputs:  dfile: pointer to HDF file to close
  1402.  * Returns: -1
  1403.  * Users:   HDF systems programmers, for error handling
  1404.  * Invokes: DFclose
  1405.  * Remarks: Used to centralize some error handling
  1406.  *---------------------------------------------------------------------------*/
  1407.  
  1408. int DFIerr(dfile)
  1409. DF *dfile;
  1410. {
  1411.     int saveerror;
  1412.  
  1413.     saveerror = DFerror;
  1414.     if (dfile!=NULL) (void) DFclose(dfile);
  1415.     DFerror = saveerror;
  1416.     return(-1);
  1417. }
  1418.